package model;

import java.sql.*;
import java.util.Enumeration;
import java.util.Properties;
import java.util.Vector;

import javax.lang.model.element.Element;

public class ConnexionDb {
		
    private Connection connect = null;
    private Statement statement = null;
	private PreparedStatement preparedStatement = null;
	private ResultSet resultSet = null;

	// Méthode assurant la connexion à la base de donnée
    
    void etablissementConnexion () throws Exception {
 
    	  Properties properties = new Properties();
		  properties.put("user", "econf");
		  properties.put("password", "3c0nF!");
		  properties.put("characterEncoding", "utf8");
		  properties.put("useUnicode", "true");
		  String url = "jdbc:mysql://127.0.0.1:5151/Econf";

		Class.forName("com.mysql.jdbc.Driver");
		connect = DriverManager.getConnection(url, properties);
		
		// simple contrôle pour le moment
		System.out.println("Connexion OK à la DB");
		
    }
    
    
    // Méthode vérifiant l'existence de l'utilisateur dans la base de donnée en fonction du login
    
    ResultSet requeteVerificationExistenceLogin(String utilisateur) throws SQLException{
    	
     	preparedStatement=connect.prepareStatement("select id_utilisateur from Utilisateur where login_utilisateur= ?");
     	preparedStatement.setString(1, utilisateur);
     	resultSet = preparedStatement.executeQuery();
     	return resultSet;
     }
    
    
    // Méthode retournant le niveau d'approbation d'un utilisateur
  
    boolean resultatApprobation (String utilisateur) throws SQLException {
    	
    	boolean value=false;
    	try {
    		preparedStatement=connect.prepareStatement("select approbation from Utilisateur where login_utilisateur= ?");
         	preparedStatement.setString(1, utilisateur);
         	resultSet = preparedStatement.executeQuery();
         	if (resultSet.next()){
         	    value = resultSet.getBoolean("approbation");
         	}
		} catch (Exception e) {
			e.printStackTrace();
			value = false;
		}
    	return value;
    }
    
    // Méthode pour l'inscription d'un nouvel utilisateur
     
     boolean InscriptionNouvelUtilisateur (Object []tabClient) throws SQLException{
    	 
    	 try {
    		 preparedStatement = connect.prepareStatement("insert into Econf.Utilisateur values (default, ?, ?, ?, ?, ?, ?, ?)");
        	 preparedStatement.setString(1,(String)  tabClient[2]); // login_utilisateur
    		 preparedStatement.setString(2,(String)  tabClient[0]); // nom_utilisateur
    		 preparedStatement.setString(3,(String)  tabClient[1]); // prenom_utilisaur
    		 preparedStatement.setString(4,(String)  tabClient[3]); // mail_utilisateur
    		 preparedStatement.setString(5,(String) tabClient[4]); // mot_de_passe
    		 preparedStatement.setString(6, "inscrit"); // groupe_utilisateur en dur	 
    		 preparedStatement.setBoolean(7, false); // Approbation (par défaut false, attente confirmation admin)
    		 preparedStatement.executeUpdate();
		} catch (Exception e) {
			return false;
		}
    	return true; 
    }
     
     // Méthode qui retourne la liste des utilisateurs en attente d'approbation
     
     String [][]retourneListeUtilisateurDemandeApprobation() throws SQLException {
    	 
    	 preparedStatement = connect.prepareStatement("select login_utilisateur, nom_utilisateur, prenom_utilisateur,mail_utilisateur from Econf.Utilisateur where approbation='0'");
    	 resultSet=preparedStatement.executeQuery();    	 
    	 //Compteur pour connaitre le nombre de ligne dans le resultset
      	int nbligne = 0;
      	while (resultSet.next()){
      		nbligne++;
      	}
      	//On se replace au début sinon on ne peut plus accèder aux données
      	resultSet.beforeFirst();
      	
    	 String [][] utilisateurNonApprouve = new String [nbligne][4];
    	 for (int i = 0; i < nbligne; i++) {
    		 if (resultSet.next()){ 
    		 utilisateurNonApprouve[i][0]= resultSet.getString("login_utilisateur");
    		 utilisateurNonApprouve[i][1]= resultSet.getString("nom_utilisateur");
    		 utilisateurNonApprouve[i][2]= resultSet.getString("prenom_utilisateur");
    		 utilisateurNonApprouve[i][3]= resultSet.getString("mail_utilisateur");
    		 }
		}
    	 return utilisateurNonApprouve;
     }
     
     
     // Méthode de validation de l'inscription d'un utilisateur
     
     void MiseJourApprobation (String utilisateur) throws SQLException{
    	 
    	 preparedStatement = connect.prepareStatement("update Econf.Utilisateur set approbation='1' where login_utilisateur= ?");
    	 preparedStatement.setString(1, utilisateur);
    	 preparedStatement.executeUpdate();
     }
     
     // Méthode d'annulation (suppression) d'inscription d'un utilisateur 
     
     void suppressionUtilisateurNonApprouve (String login) throws SQLException {
    	 
    	 preparedStatement = connect.prepareStatement("delete from Econf.Utilisateur where login_utilisateur= ?");
    	 preparedStatement.setString(1, login);
    	 preparedStatement.executeUpdate();
     }
     
     
     
     // Méthode retournant le mail de l'utilisateur en fonction du login
     
     public String renvoiMailUtilisateurFonctionLogin (String login) throws SQLException {
    	
    	 String mailUser=null;
    	 preparedStatement = connect.prepareStatement("select mail_utilisateur from Utilisateur where login_utilisateur=?");
    	 preparedStatement.setString(1, login);
    	 resultSet = preparedStatement.executeQuery();
    	 
    	 try {
			if (resultSet.next()){
				mailUser= resultSet.getString("mail_utilisateur");
			}
			else {
				//log ?
			}
			
		} catch (Exception e) {
			
			e.printStackTrace();
		}
    	 
    	 return mailUser;
     }
     
       // Méthode retournant le mail de l'utilisateur en fonction du l'id utilisateur
     
     public String renvoiMailUtilisateurFonctionIdUtilisateur (int idUser) throws SQLException {
     	
    	 String mailUser=null;
    	 preparedStatement = connect.prepareStatement("select mail_utilisateur from Utilisateur where id_utilisateur=?");
    	 preparedStatement.setInt(1, idUser);
    	 resultSet = preparedStatement.executeQuery();
    	 
    	 try {
			if (resultSet.next()){
				mailUser= resultSet.getString("mail_utilisateur");
			}
			else {
				//log ?
			}
			
		} catch (Exception e) {
			
			e.printStackTrace();
		}
    	 
    	 return mailUser;
     }
     
    
      // Méthode retournant le résultat de la requête SQL d'identification 
     
     ResultSet requeteIdentification(String utilisateur) throws SQLException{
    	 
     	preparedStatement=connect.prepareStatement("select mot_de_passe, groupe_utilisateur from Utilisateur where login_utilisateur= ?");
     	preparedStatement.setString(1, utilisateur);
     	resultSet = preparedStatement.executeQuery();
     	return resultSet;
     }
     
     // Méthode qui permet de déterminer le groupe et le mot de passe d'un utilisateur lors de son identification
     
     String[] rendreResultatIdentification(ResultSet resultSet) throws SQLException {
    	
    	String mot_de_passe=null;
    	String groupe=null;
    	String []tabResultatIdentification = new String [2];
		// Parcours du résultat de la requête
		while (resultSet.next()) {
		    tabResultatIdentification[0] = resultSet.getString("mot_de_passe");
		    tabResultatIdentification[1] = resultSet.getString("groupe_utilisateur");
		   
		}
		return tabResultatIdentification;
	}
    
    // Méthode pour la création de conférence 
    
    boolean creationConference (Object []tabClient)throws SQLException{
    	
    	try {
    		
    		Courriel email = new Courriel();
    		
    		// Formatage des données pour la date
    		int annee = (new Integer(tabClient[7].toString()));
    		int moi = correspondanceMoiNumérique((String)tabClient[6]);
    		int jour = (new Integer(tabClient[5].toString()));
    		String date = annee +"-" +moi +"-" +jour;
    		// Formatage des données pour l'heure
    		String horaireDebut = tabClient[8] +":" +tabClient[9] +":00";
    		String horaireFin = tabClient[10] +":" +tabClient[11] +":00";
    		// Formatage pour insertion dans la base
    		String debutConf = date +" " +horaireDebut;
    		String finConf = date +" " +horaireFin;
    		preparedStatement = connect.prepareStatement("insert into Econf.Conference values (default, ?, ?, ?, ?, ?, ?, ?, ?, ?)");
    		preparedStatement.setString(1,"Créer"); // Statut
    		preparedStatement.setInt(2,4); // nbParticipant
    		//Demander l'envoi dans le tableau client, le nombre de participant
			preparedStatement.setString(3,(String)  tabClient[4]); //Type
			preparedStatement.setString(4,(String) tabClient[0]); // Sujet
			preparedStatement.setString(5,(String) tabClient[1]); // Titre
			preparedStatement.setString(6,(String) tabClient[2]); // Conférencier
			if (((String)tabClient[3]).equals("")){
				preparedStatement.setString(7,(String) tabClient[2]); // Admin de Conférence = Conférencier
			}
			else {
				preparedStatement.setString(7,(String) tabClient[3]); // Admin de Conférence différent du conférencier
			}
			preparedStatement.setString(8,debutConf); //date heure début
			preparedStatement.setString(9,finConf); // date heure fin
			preparedStatement.executeUpdate();
			// Traitement pour ajout des informations dans la table participe
			int lastIdConference = retourneDernierIDConf();
			int nbParticipant = 0;
			// Taitement des participants
			// Traitement pour le conférencier
			String [] tabConferencier= ((String)tabClient[2]).split(" ");
			int idPartConferencier= renvoiIdUtilisateurFonctionPrenomNom(tabConferencier[0],tabConferencier[1]);
			insertionDonneeTableParticipe(idPartConferencier, lastIdConference, "conferencier");
			// Traitement des autres participants
			if (!((String)tabClient[12]).equals("")){
					nbParticipant++;
					String [] tabpart1= ((String)tabClient[12]).split(" ");
					int idPart1= renvoiIdUtilisateurFonctionPrenomNom(tabpart1[0],tabpart1[1]);
					insertionDonneeTableParticipe(idPart1, lastIdConference, (String) tabClient[13]);
//					String dest = renvoiMailUtilisateurFonctionIdUtilisateur(idPart1);
//					email.sendInvitation(dest, date, (String)tabClient[2],(String)tabClient[0]);
		    }
			if (!((String)tabClient[14]).equals("")){
				nbParticipant++;
				String [] tabpart2= ((String)tabClient[14]).split(" ");
				int idPart2= renvoiIdUtilisateurFonctionPrenomNom(tabpart2[0],tabpart2[1]);
				insertionDonneeTableParticipe(idPart2, lastIdConference, (String) tabClient[15]);
//				String dest = renvoiMailUtilisateurFonctionIdUtilisateur(idPart2);
//				email.sendInvitation(dest, date, (String)tabClient[2],(String)tabClient[0]);
			}	
			if (!((String)tabClient[16]).equals("")){
				nbParticipant++;
				String [] tabpart3= ((String)tabClient[16]).split(" ");
				int idPart3= renvoiIdUtilisateurFonctionPrenomNom(tabpart3[0],tabpart3[1]);
				insertionDonneeTableParticipe(idPart3, lastIdConference, (String) tabClient[17]);
//				String dest = renvoiMailUtilisateurFonctionIdUtilisateur(idPart3);
//				email.sendInvitation(dest, date, (String)tabClient[2],(String)tabClient[0]);
				}
			if (!((String)tabClient[18]).equals("")){
					nbParticipant++;
					String [] tabpart4= ((String)tabClient[18]).split(" ");
					int idPart4= renvoiIdUtilisateurFonctionPrenomNom(tabpart4[0],tabpart4[1]);
					insertionDonneeTableParticipe(idPart4, lastIdConference, (String) tabClient[19]);
//					String dest = renvoiMailUtilisateurFonctionIdUtilisateur(idPart4);
//					email.sendInvitation(dest, date, (String)tabClient[2],(String)tabClient[0]);
				}
			// MAJ du nombre de participant suite à vérification
			preparedStatement = connect.prepareStatement("update Econf.Conference set Conference.nb_participant=? where Conference.id_conference=?");
			preparedStatement.setInt(1,nbParticipant); // nbParticipant
			preparedStatement.setInt(2,lastIdConference);
			preparedStatement.executeUpdate();
			
		} catch (Exception e) {
			e.printStackTrace();
			return false;
		}
    	return true;
    }
    
    // Méthode qui retourne l'ID de la de la dernière conférence présente dans la table conférence
    
   int retourneDernierIDConf() throws SQLException{
	   
	   int lastIDConf = 0;
	   preparedStatement = connect.prepareStatement("select MAX(id_conference) from Conference");
	   resultSet = preparedStatement.executeQuery();
	   if (resultSet.next()){
		   lastIDConf= resultSet.getInt("MAX(id_conference)");
	   }	   
	  return lastIDConf; 
   }
   
   // Méthode pour faire la correspondance entre la version alphabétique et la version numérique des mois
    
    int correspondanceMoiNumérique (String versionAlphabet){
    	
        int versionNumerique = 0;
        Vector vec = new Vector();
        vec.add("Janvier");
        vec.add(1);
        vec.add("Février");
        vec.add(2);
        vec.add("Mars");
        vec.add(3);
        vec.add("Avril");
        vec.add(4);
        vec.add("Mai");
        vec.add(5);
        vec.add("Juin");
        vec.add(6);
        vec.add("Juillet");
        vec.add(7);
        vec.add("Août");
        vec.add(8);
        vec.add("Septembre");
        vec.add(9);
        vec.add("Octobre");
        vec.add(10);
        vec.add("Novembre");
        vec.add(11);
        vec.add("Décembre");
        vec.add(12);
        for (Enumeration e = vec.elements();e.hasMoreElements();) {
        		if (e.nextElement().equals(versionAlphabet)){
            		versionNumerique=(Integer)e.nextElement();
        			}
        	}

        return versionNumerique;
    }
    
    // Méthode pour ajouter des participants dans la table participe
    
    void insertionDonneeTableParticipe(int idParticipant, int idConference, String roleParticipant) throws SQLException{
    	
    	preparedStatement=connect.prepareStatement("insert into Econf.Participe values (?,?,?)");
    	preparedStatement.setInt(1, idParticipant);
    	preparedStatement.setInt(2, idConference);
    	preparedStatement.setString(3, roleParticipant);
    	preparedStatement.executeUpdate();
   	
    }
    
    // Méthode pour afficher les utilisateurs qui pourront être invités dans des conférences
    
    String [] affichageUtilisateurComboxBox () throws SQLException {
    	
    	preparedStatement=connect.prepareStatement("select nom_utilisateur, prenom_utilisateur from Utilisateur where approbation=1");
     	resultSet = preparedStatement.executeQuery();
//	    Compteur pour connaitre le nombre de ligne dans le resultset
     	int nbligne = 0;
     	while (resultSet.next()){
     		nbligne++;
     	}
//     	 On se replace au début sinon on ne peut plus accèder aux données
     	resultSet.beforeFirst();
     	
     	String [] tabUtilisateurApprouve = new String [nbligne];
     	tabUtilisateurApprouve[0]="";
     	
     	// on commence à 1 (deuxieme ligne, la premiere est réservée pour le caractère vide " ")
     	for (int i = 1; i < nbligne; i++) {
     		if (resultSet.next()){
     		tabUtilisateurApprouve[i] = resultSet.getString("prenom_utilisateur")+ " " +resultSet.getString("nom_utilisateur");
     		
     							 }
     	
     	}
     	return tabUtilisateurApprouve;
    }
    
    // Méthode pour afficher les informations dans la section "Conférence" de l'utilisateur pour les conférences privées
     
    ResultSet donneesConferencesUtilisateur( int idConference, int idUtilisateur)  throws SQLException{
 
    	preparedStatement=connect.prepareStatement("select distinct Conference.id_conference, statut, nb_participant, type, titre, sujet, nom_conferencier, nom_admin_conference, date_heure_debut, date_heure_fin, Participe.role from Conference, Participe  where  Conference.id_conference=? and Participe.id_utilisateur=? and Conference.id_conference = Participe.id_conference");
     	preparedStatement.setInt(2, idUtilisateur);
     	preparedStatement.setInt(1, idConference);
     	resultSet= preparedStatement.executeQuery();
     	

       	return resultSet;
   		}
    
    // Méthode pour afficher les informations dans la section "Conférence" de l'utilisateur pour les conférences publiques
      
    ResultSet donneesConferencesPublique(int idConference)  throws SQLException {
    	
    	preparedStatement=connect.prepareStatement("select distinct Conference.id_conference, statut, nb_participant, type, titre, sujet, nom_conferencier, nom_admin_conference, date_heure_debut, date_heure_fin from Conference  where  Conference.id_conference=?");
     	preparedStatement.setInt(1, idConference);
     	resultSet= preparedStatement.executeQuery();
    	
    	return resultSet;
    }
    
    // Méthode pour connaître l'id d'un utilisateur en fonction du login
    
	  int renvoiIdUtilisteur (String login)  throws SQLException{
	    	preparedStatement=connect.prepareStatement("select id_utilisateur from Utilisateur where login_utilisateur= ?");
	     	preparedStatement.setString(1, login);
	     	resultSet = preparedStatement.executeQuery();
	    	
	     	int id = 0;
	     	
	     	if (resultSet.next()){
	     		
	     		 id = resultSet.getInt("id_utilisateur");
	     	}
	     	return id;
	    }
	  
	  // Méthode pour connaître l'id d'un utilisateur en fonction du Nom et du Prenom de l'utilisateur
	  
	  int renvoiIdUtilisateurFonctionPrenomNom(String prenom, String nom) throws SQLException{
		  preparedStatement=connect.prepareStatement("select id_utilisateur from Utilisateur where nom_utilisateur= ? and prenom_utilisateur=?");
	      preparedStatement.setString(1, nom);
	      preparedStatement.setString(2, prenom);
	      resultSet = preparedStatement.executeQuery();
	     	int id = 0;
	     	if (resultSet.next()){
	     		
	     		 id = resultSet.getInt("id_utilisateur");
	     	}
	     	return id;
	    }
	  
	  // Méthode pour connaître  le Nom et du Prenom de l'utilisateur en fonction l'id d'un utilisateur
	  
	  
	  String renvoiPrenomNomUtilisateurFonctionLoginUtilisateur (String loginUser) throws SQLException{
		  
		  preparedStatement=connect.prepareStatement("select prenom_utilisateur, nom_utilisateur from Utilisateur where login_utilisateur=?");
		  preparedStatement.setString(1, loginUser);
		  resultSet = preparedStatement.executeQuery();
		  String prenomNom = null;
		  if (resultSet.next()){
			 prenomNom =resultSet.getString("prenom_utilisateur")+ " "+resultSet.getString("nom_utilisateur");
		  }
		  else{
			  //log ?
		  }
		  return prenomNom;
	  }
	  
	  
	  String [] renvoiNomPrenomMailUtilisateurFonctionLogin (String loginUser) throws SQLException {
		  
		  String [] dataUser = new String [4];
		  try {
			  preparedStatement=connect.prepareStatement("select prenom_utilisateur, nom_utilisateur, mail_utilisateur from Utilisateur where login_utilisateur=?");
			  preparedStatement.setString(1, loginUser);
			  resultSet = preparedStatement.executeQuery();
			  	  if (resultSet.next()){
					  dataUser[0]=resultSet.getString("prenom_utilisateur");
					  dataUser[1]=resultSet.getString("nom_utilisateur");
					  // On remet en dur le login pour l'affichage côté client
					  dataUser[2]=loginUser;
					  dataUser[3]=resultSet.getString("mail_utilisateur");
					 
				  }
				  else{
					  //log ?
				  }
		  	} catch (Exception e) {
		  				e.printStackTrace();
		  	}
		
		  return dataUser; 
	  }
	  
		// Méthode qui retourne les id des conférences publiques où l'utilisateur  à pour rôle conférencier  
	  
	  int [] renvoiIdConferencePubliqueUtilisateurConferencier (int idUtilisateur, String prenomNom)  throws SQLException {
		  
		  preparedStatement=connect.prepareStatement("select id_conference from Conference, Utilisateur where id_utilisateur=? and Conference.nom_conferencier=? and Conference.type= ? ");
		  preparedStatement.setInt(1,idUtilisateur);
		  preparedStatement.setString(2, prenomNom);
		  preparedStatement.setString(3, "publique");
		  resultSet = preparedStatement.executeQuery();
//		    Compteur pour connaitre le nombre de ligne dans le resultset
	     	int nbligne = 0;
	     	while (resultSet.next()){
	     		nbligne++;
	     	}
//	     	 On se replace au début sinon on ne peut plus accèder aux données
	     	resultSet.beforeFirst();
//	     	// On utilise le résultat pour effectuer le traitement sur le nombre de ligne indiqué
	
		   	int [] tabid = new int [nbligne];
		   	for (int i = 0; i < nbligne; i++) {
		   					
		   	if (resultSet.next()){
		   		 tabid[i] = resultSet.getInt("id_conference");
		   	   }
		   	}
		   	return tabid;
		  }
	  
	  // Méthode qui retourne les id des conférences publiques où l'utilisateur  à pour rôle administrateur de conférence
	  
	  int [] renvoiIdConferencePubliqueUtilisateurAdminConference (int idUtilisateur, String prenomNom)  throws SQLException {
		  
		  preparedStatement=connect.prepareStatement("select id_conference from Conference, Utilisateur where id_utilisateur=? and Conference.nom_admin_conference=? and not Conference.nom_conferencier=? and Conference.type=?");
		  preparedStatement.setInt(1,idUtilisateur);
		  preparedStatement.setString(2, prenomNom);
		  preparedStatement.setString(3, prenomNom);
		  preparedStatement.setString(4, "publique");
		  resultSet = preparedStatement.executeQuery();
//		    Compteur pour connaitre le nombre de ligne dans le resultset
	     	int nbligne = 0;
	     	while (resultSet.next()){
	     		nbligne++;
	     	}
//	     	 On se replace au début sinon on ne peut plus accèder aux données
	     	resultSet.beforeFirst();
	     	// On utilise le résultat pour effectuer le traitement sur le nombre de ligne indiqué
		   	int [] tabid = new int [nbligne];
		   	for (int i = 0; i < nbligne; i++) {
		   					
		   	if (resultSet.next()){
		   		 tabid[i] = resultSet.getInt("id_conference"); 		
		   		}
		   	}
		   	return tabid; 
	  }
 
	  // Méthode renvoyant un tableau contenant les id des conférences privés où l'utilisateur courant est invité
	  
	  int [] renvoiIdConferencePriveeUtilisateur (int idUtilisateur)  throws SQLException {
		  
			preparedStatement=connect.prepareStatement("select distinct Conference.id_conference from Participe, Conference where id_utilisateur=? and Conference.type='privée'");
		   	preparedStatement.setInt(1, idUtilisateur);
		   	resultSet = preparedStatement.executeQuery();
//		    Compteur pour connaitre le nombre de ligne dans le resultset
	     	int nbligne = 0;
	     	while (resultSet.next()){
	     		nbligne++;
	     	}
//	     	 On se replace au début sinon on ne peut plus accèder aux données
	     	resultSet.beforeFirst();
//	     	// On utilise le résultat pour effectuer le traitement sur le nombre de ligne indiqué
  	
		   	int [] tabid = new int [nbligne];
		   	for (int i = 0; i < nbligne; i++) {
		   					
		   	if (resultSet.next()){
		   		 tabid[i] = resultSet.getInt("id_conference");
		   		}
		   	}
		   	return tabid;
		  }
	  
	// Méthode renvoyant un tableau contenant les id des conférences publiques
  
	  int [] renvoiIdConferencePublique ()  throws SQLException {
		  
		    preparedStatement=connect.prepareStatement("select id_conference from Conference where Conference.type= ?");
		   	preparedStatement.setString(1, "publique");
		   	resultSet = preparedStatement.executeQuery();
//		    Compteur pour connaitre le nombre de ligne dans le resultset
	     	int nbligne = 0;
	     	while (resultSet.next()){
	     		nbligne++;
	     	}
//	     	 On se replace au début sinon on ne peut plus accèder aux données
	     	resultSet.beforeFirst();
//	     	// On utilise le résultat pour effectuer le traitement sur le nombre de ligne indiqué
	
		   	int [] tabid = new int [nbligne];
		   	for (int i = 0; i < nbligne; i++) {
		   					
		   	if (resultSet.next()){
		   		 tabid[i] = resultSet.getInt("id_conference");
		   		}
		   	}
		   	return tabid;
	  }
	  
	  // Section Monitoring
	  
	  // Méthode retournant le nombre de conférence publique avec le statut Créer
	  
	int monitoringConferenceCreePublique () throws SQLException {
		
		int nb = 0;
		preparedStatement=connect.prepareStatement("select count(*) from Conference where Conference.type=? and Conference.statut=?");
	   	preparedStatement.setString(1, "publique");
	   	preparedStatement.setString(2, "Créer");
	   	resultSet = preparedStatement.executeQuery();
	 	if (resultSet.next()){
	   		 nb = resultSet.getInt("count(*)");
	   		}
	 	else {
	 		// log ?
	 	}
		return nb;	
	}
	
	
	
	// Méthode retournant le nombre de conférence publique avec le statut En cours
	
	int monitoringConferenceEnCoursPublique ()  throws SQLException {
		
		int nb = 0;
		preparedStatement=connect.prepareStatement("select count(*) from Conference where Conference.type=? and Conference.statut=?");
	   	preparedStatement.setString(1, "publique");
	   	preparedStatement.setString(2, "En cours");
	   	resultSet = preparedStatement.executeQuery();
	 	if (resultSet.next()){
	   		 nb = resultSet.getInt("count(*)");
	   		}
	 	else {
	 		// log ?
	 	}
		return nb;	
	}
	
	
	
	// Méthode retournant le nombre de conférence publique avec le statut En cours
	
	int monitoringConferenceTerminerPublique ()  throws SQLException {
		
		int nb = 0;
		preparedStatement=connect.prepareStatement("select count(*) from Conference where Conference.type=? and Conference.statut=?");
	   	preparedStatement.setString(1, "publique");
	   	preparedStatement.setString(2, "Terminer");
	   	resultSet = preparedStatement.executeQuery();
	 	if (resultSet.next()){
	   		 nb = resultSet.getInt("count(*)");
	   		}
	 	else {
	 		// log ?
	 	}
		return nb;	
	}
	
	
	
	// Méthode retournant le nombre de conférence privée avec le statut Créer
	
	int monitoringConferenceCreePrivee ()  throws SQLException {
		
		int nb = 0;
		preparedStatement=connect.prepareStatement("select count(*) from Conference where Conference.type=? and Conference.statut=?");
	   	preparedStatement.setString(1, "privée");
	   	preparedStatement.setString(2, "Créer");
	   	resultSet = preparedStatement.executeQuery();
	 	if (resultSet.next()){
	   		 nb = resultSet.getInt("count(*)");
	   		}
	 	else {
	 		// log ?
	 	}
		return nb;	
	}
	
	
	// Méthode retournant le nombre de conférence privée avec le statut En cours
	
	int monitoringConferenceEnCoursPrivee ()  throws SQLException {
		
		int nb = 0;
		preparedStatement=connect.prepareStatement("select count(*) from Conference where Conference.type=? and Conference.statut=?");
	   	preparedStatement.setString(1, "privée");
	   	preparedStatement.setString(2, "En cours");
	   	resultSet = preparedStatement.executeQuery();
	 	if (resultSet.next()){
	   		 nb = resultSet.getInt("count(*)");
	   		}
	 	else {
	 		// log ?
	 	}
		return nb;	
	}
	
	
	// Méthode retournant le nombre de conférence privée avec le statut Terminer
	
	int monitoringConferenceTerminerPrivee ()  throws SQLException {
		
		int nb = 0;
		preparedStatement=connect.prepareStatement("select count(*) from Conference where Conference.type=? and Conference.statut=?");
	   	preparedStatement.setString(1, "privée");
	   	preparedStatement.setString(2, "Terminer");
	   	resultSet = preparedStatement.executeQuery();
	 	if (resultSet.next()){
	   		 nb = resultSet.getInt("count(*)");
	   		}
	 	else {
	 		// log ?
	 	}
		return nb;	
	}
	
	
	// Méthode retournant le nombre d'utilisateur dont l'inscription a été validée, approuvée
	
	int monitoringUtilisateursInscrit ()  throws SQLException {
		
		int nb = 0;
		preparedStatement=connect.prepareStatement("select count(*) from Utilisateur where Utilisateur.approbation=?");
	   	preparedStatement.setInt(1,1);
	   	resultSet = preparedStatement.executeQuery();
	 	if (resultSet.next()){
	   		 nb = resultSet.getInt("count(*)");
	   		}
	 	else {
	 		// log ?
	 	}
		return nb;	
	}
	
	// Méthode retournant le nombre d'utilisateur dont l'inscription n'a pas encore été validée.
	
	int monitoringUtilisateursNonInscrit ()  throws SQLException {
		
		int nb = 0;
		preparedStatement=connect.prepareStatement("select count(*) from Utilisateur where Utilisateur.approbation=?");
	   	preparedStatement.setInt(1,0);
	   	resultSet = preparedStatement.executeQuery();
	 	if (resultSet.next()){
	   		 nb = resultSet.getInt("count(*)");
	   		}
	 	else {
	 		// log ?
	 	}
		return nb;	
	}
	
	
	  // Méthode pour fermer proprement la connexion entre le serveur et la base de donnée
    
    void fermetureConnexion() {
    	
		try {
				if (resultSet != null) {
						resultSet.close();
										}

					if (statement != null) {
						statement.close();
											}		

						if (connect != null) {
							connect.close();
											}
			} catch (Exception e) {}
			
								}

}
// fin de la classe
